// Copyright (c) 2005  INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of cgal-python; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with cgal-python.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $Id: Py_Alpha_shape_2_doc.h 159 2007-11-02 09:54:13Z spion $
// $URL: svn+ssh://scm.gforge.inria.fr/svn/cgal-python/trunk/cgal-python/bindings/Alpha_shapes_2/Py_Alpha_shape_2_doc.h $
// $Date: 2007-11-02 10:54:13 +0100 (Ven 02 nov 2007) $
// Author(s)     : Naceur Meskini
//=========================================================================

#ifndef ALPHA_SHAPE_2_DOCS_H
#define ALPHA_SHAPE_2_DOCS_H
//=======================================================
// doc of Alpha_shape_2 class
//=======================================================
const char* Alpha_shape_2_doc = "\
	The class Alpha_shape_2 represents the family of alpha-shapes \n\
	of points in a plan for all positive alpha. \n\
	It maintains an underlying triangulation of the class \n\
	Delaunay_triangulation_2 Dt which represents connectivity and \n\
	order among its faces. Each k-dimensional face of the Dt is associated\n\
	with an interval that specifies for which values of  the face belongs to the alpha shape.\n\
	for more details See:\n\
	http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Alpha_shapes_2_ref/Class_Alpha_shape_2.html\n\
	";

const char* make_alpha_shape_doc = "\
	A.make_alpha_shape( self , list L) -> int\n\
	Initialize the alpha shape data structure for points in the list L. \n\
	Returns the number of data points inserted in the underlying triangulation.\n\
	If the function is applied to an non-empty alpha shape data structure,\n\
	it is cleared before initialization.";

const char* clear_doc = "\
	A.clear( self) -> Clears the structure.";

const char* set_alpha_doc = "\
	A.set_alpha( self ,alpha) -> double\n\
	Sets the alpha-value to alpha. Returns the previous alpha-value.\n\
	Precondition: alpha >= 0.";

const char* get_alpha_doc = "\
	get_alpha( self ) -> double\n\
	Returns the current alpha-value.";

const char* get_nth_alpha_doc = "\
	A.get_nth_alpha( self , int n) -> double\n\
	Returns the n-th alpha-value, sorted in an increasing order.\n\
	Precondition: n < number of alphas.";

const char* number_of_alphas_doc = "\
	A.number_of_alphas( self) -> int \n\
	Returns the number of different alpha-values.";

const char* set_mode_doc = "\
	A.set_mode( self , Mode m = GENERAL) -> Mode\n\
	Sets A in GENERAL or REGULARIZED.Returns the previous mode.";

const char* get_mode_doc = "\
	A.get_mode( self) -> Mode\n\
	Returns whether A is general or regularized.";

const char* alpha_find_doc = "\
	A.alpha_find( self ,alpha) -> Alpha_iterator\n\
	Returns an iterator pointing to an element with alpha-value alpha,\n\
	or the corresponding past-the-end iterator if such an element is not found.\n\
	to get the value of the returned iterator, use the next() function:\n\
	it = A.alpha_find(2) ; value_of_alpha = it.next()";

const char* alpha_lower_bound_doc = "\
	A.alpha_lower_bound( self , alpha) -> Alpha_iterator\n\
	Returns an iterator pointing to the first element with alpha-value \n\
	not less than alpha.\n\
	to get the value of the returned iterator,use the next() function";

const char* alpha_upper_bound_doc = "\
	A.alpha_upper_bound( self , alpha) -> Alpha_iterator\n\
	Returns an iterator pointing to the first element with \n\
	alpha-value greater than alpha.\n\
	to get the value of the returned iterator, use the next() function.";

const char* classify_doc = "\
	A.classify( Self ,Point_2 p, alpha = get_alpha()) -> Classification_type\n\
	Locates a point p in the underlying triangulation and Classifies \n\
	the associated k-face with respect to alpha.\n\n\
	A.classify( Self ,Face f, alpha = get_alpha()) -> Classification_type\n\
	Classifies the face f of the underlying triangulation with respect to alpha.\n\n\
	A.classify( Self ,Edge e, alpha = get_alpha()) -> Classification_type\n\
	Classifies the edge e of the underlying triangulation with respect to alpha.\n\n\
	A.classify( Self ,Face f,int i,alpha = get_alpha()) -> Classification_type\n\
	Classifies the facet of the face f opposite to the vertex with index i of \n\
	the underlying triangulation with respect to alpha.\n\n\
	A.classify( Self ,Edge e, alpha = get_alpha()) -> Classification_type\n\
	Classifies the edge e with respect to alpha .\n\n\
	A.classify( Self ,Vertex v, alpha = get_alpha()) -> Classification_type\n\
	Classifies the vertex v of the underlying triangulation with respect to alpha.";

const char* number_of_solid_components_doc = "\
	A.number_of_solid_components( self , double alpha = get_alpha()) -> int\n\
	Returns the number of solid components of A, that is, \n\
	the number of components of its regularized version. ";

const char* find_optimal_alpha_doc = "\
	A.find_optimal_alpha( self , int nb_components) -> Alpha_iterator\n\
	Returns an iterator pointing to smallest value such that A satisfies \n\
	the following two properties:\n\
	all data points are either on the boundary or in the interior of the \n\
	regularized version of A.\n\
	The number of solid component of A is equal to or smaller than nb_components.";


const char* alpha_shape_edges_doc = "\
is a property that contains the alpha_shape edges.";

const char* alpha_shape_vertices_doc = "\
Is property that contains the alpha shape vertices.";


const char* alpha_doc = "\
	is an iterator that allows to traverse the sorted sequence of alpha-values of the family of alpha shapes.";

#endif  //ALPHA_SHAPE_2_DOCS_H
